package sort.test4_7;

import java.util.Arrays;
import java.util.Scanner;
import java.util.Arrays;
import java.util.*;
public class Main {
//
//    public   int[]  radixSort(int[]  nums){
//        if (nums.length==0){
//            return nums;
//        }
//        int max=Integer.MIN_VALUE;
//        for (int i = 0; i < nums.length; i++) {
//            if (nums[i]>max){
//                max=nums[i];
//            }
//        }
//        for (int exp = 1; max/exp>0 ; exp*=10) {
//            sort(nums,exp);
//        }
//        return  nums;
//    }
//
//    public   void  sort(int[] nums,int exp){
//        int[] countArray = new int[10];
//        int[] output = new int[nums.length];
//        for (int i = 0; i < nums.length; i++) {
//            countArray[(nums[i]/exp)%10]++;
//        }
//        for (int i = 1; i < countArray.length; i++) {
//            countArray[i]+=countArray[i-1];
//        }
//        for (int i = nums.length-1; i>=0  ; i--) {
//            output[--countArray[(nums[i]/exp)%10]]=nums[i];
////            countArray[(nums[i]/exp)%10]--;
//        }
//
//        for (int i = 0; i < nums.length ; i++) {
//            nums[i]=output[i];
//        }
//        output=null;
//        countArray=null;
//    }
//
//
//    public static void main(String[] args) {
//
//        RadixSort radixSort = new RadixSort();
//        int arr[] ={3,44,38,5,47,15,36,26,27,2,46,4,19,50,48};
//        radixSort.radixSort(arr);
//        System.out.println(Arrays.toString(arr));
//    }

        List<List<Integer>>   result= new ArrayList<>();
        //TODO:2023/8/24 这里又发现了问题 下面这样是可以的
        List<Integer> path= new ArrayList<>();
//        LinkedList<Integer> path = new LinkedList<Integer>();

    //TODO:2023/8/24  record 与sum  不是全局变量也可以
       boolean[] record;
int sum =0;
        public  static void main(String[]  args){

            Main main= new Main();
            int res=main.find();
            if(res==-1){
                System.out.println("No  solution");
            }else{
//                System.out.println(res);
            }

        }

        int find(){
            Scanner sc=new Scanner(System.in);
            int N=sc.nextInt();
            int M=sc.nextInt();
            int[] nums=new int[N];
            for(int i=0;i<N;i++){
                nums[i]=sc.nextInt();
            }
            Arrays.sort(nums);
            record= new boolean[N];
            Arrays.fill(record,false);

           findMin(nums,M,0);

            int min=Integer.MAX_VALUE;
            if(result==null){
                return -1;
            }
            for(int i=0;i<result.size();i++){
                min=Math.min(min,result.get(i).size());
            }
            return min;
        }


        void findMin(int[] nums,int M,int  start){
           //TODO:2023/8/24  1， 这里的判断顺序可能会有问题
            //TODO:2023/8/24 将下面这个判断放到 for循环里面 减少一层递归
//            if(sum>M){
//                return;
//            }
            //TODO:2023/8/24 下面这种数组下标越界是不会出现的  属于无效判断
//            if(start>nums.length-1){
//                return;
//            }
            if(sum==M){
                result.add(new ArrayList<>(path));
                return;
            }
            for(int i=start;i<nums.length;i++){
                if(sum+nums[i]>M){
                    //TODO:2023/8/24  此处return  break都可以 结果一样
//                    return;
                    break;
                }
                if(i>0&&nums[i]==nums[i-1]&&!record[i-1]){
                    continue;
                }
                path.add(nums[i]);
                record[i]=true;
                sum+=nums[i];
                System.out.print("=================================");
                Iterator<Integer> iterator = path.iterator();
                while (iterator.hasNext()){
                    System.out.print(iterator.next()+" ");
                }
                System.out.println();
                //TODO:2023/8/24 tmd  耗费老子两个小时呢   就是start的位置的原因
                findMin(nums,M,i+1);
//                path.remove(path.size()-1);
                path.remove(path.size()-1);
                record[i]=false;
                sum-=nums[i];
            }
        }

    }





